home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / programm / AGNUS / SRC / SYSINFO / SYSINFO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-01  |  13.7 KB  |  617 lines
  1. /*
  2.  *    Sys-Info, TTP-Version
  3.  *
  4.  *    Autor:    Volker Hemsen
  5.  *    Status:    Public Domain
  6.  *
  7.  *    1.0        26. Dezember 1993
  8.  *    1.1        28./31. März 1994
  9.  *    1.2        22. Mai 1996
  10.  *    1.3        03. Juli 1996
  11.  *    1.4        07. Juli 1996
  12.  *    1.5        15. September 1996
  13.  *    1.6        01. März 1998
  14.  *
  15.  *    Compiler:    GNU-C 2.5.8
  16.  */
  17.  
  18. /*
  19.  *    Include-Dateien
  20.  */
  21. #include <compiler.h>
  22. #include <stdio.h>
  23. #include <string.h>
  24. #include <osbind.h>
  25. #include "icb.h"
  26. #include <xhdi\xhdi.h>
  27.  
  28. volatile long __stksize=10*1024;
  29. #include <aesbind.h>
  30. #include <vdibind.h>
  31. #include <xlb.h>
  32. #define __stdargs
  33. extern unsigned short    _global[];
  34. #define _AESglobal _global
  35. #ifndef __MAKE_DEBUG__
  36. # define vq_gdos vq_vgdos
  37. #endif
  38. long get_long(long *aptr);
  39. long get_long(long *aptr)
  40. {
  41.     static long lpeek(void)
  42.     {
  43.         return *aptr;
  44.     }
  45.     return Supexec(lpeek);
  46. }
  47.  
  48.  
  49. /*
  50.  *    defines & typedefs
  51.  */
  52. #define VERSION        0x0160
  53. #define DATE            "12/93-03/98"
  54. #define PHYSTOP        ((long*)0x042E)
  55. #define RAMVALID    ((long*)0x05A8)
  56. #define RAMTOP        ((long*)0x05A4)
  57. #define SYSBASE        ((long*)0x04F2)
  58. #define PUNPTR        ((long*)0x0516)
  59. #define NFLOPS        ((long*)0x04A4)
  60. #define AHDI            0x41484449L
  61. #define _nAES            0x6e414553L
  62. #ifndef ULONG
  63. #define ULONG unsigned long
  64. #endif
  65.  
  66. typedef struct _dosdate
  67. {
  68.     unsigned year        : 7;
  69.     unsigned month    : 4;
  70.     unsigned day        : 5;
  71. } DOSDATE;
  72.  
  73. typedef struct _osheader
  74. {
  75.     short    os_entry;
  76.     short    os_version;
  77.     void    *reseth;
  78.     struct _osheader *os_beg;
  79.     void    *os_end;
  80.     long    os_rsv1;
  81.     void    *os_magic;
  82.     long    os_date;
  83.     short    os_conf;
  84.     short    os_dosdate;
  85. } OSHEADER;
  86.  
  87. typedef struct
  88. {
  89.     short    nvdi_version;
  90.     long    nvdi_datum;
  91.     struct {
  92.         unsigned        :    9;
  93.         unsigned alert    :    1;
  94.         unsigned         :    1;
  95.         unsigned linea    :    1;
  96.         unsigned mouse    :    1;
  97.         unsigned gemdos    :    1;
  98.         unsigned fehler    :    1;
  99.         unsigned gdos    :    1;
  100.     } nvdi_config;
  101. } NVDI_STRUCT;
  102.  
  103. typedef struct
  104. {
  105.     short    puns;
  106.     char    pun[16];
  107.     long    part_start[16];
  108.     long    P_cookie;
  109.     long    *P_cookptr;
  110.     unsigned short    P_version;
  111.     unsigned short    P_max_sector;
  112.     long    reserved[16];
  113. } PUN_INFO;
  114.  
  115. typedef struct
  116. {
  117.     ULONG    drivemap;
  118.     char    *version;
  119.     long    reserved[2];
  120. } METAINFO;
  121.  
  122. #define RESERVED_SIZE    10
  123. typedef struct {
  124.     DOSDATE    date;
  125.     short    (*reserve)(void);
  126.     short    (*init)(void);
  127.     short    (*deinit)(void);
  128.     short    (*switch_output)(void);
  129.     char    *text_buffer;
  130.     short    max_lines,x_size,y_size,x_vis,y_vis,x_off,y_off,
  131.                 char_w,char_h,vdi_handle,text_offset,curser_handle,
  132.                 reserved[RESERVED_SIZE];
  133. }    TOS2GEM_COOKIE;
  134.  
  135. typedef struct {
  136.     unsigned short version;
  137.     unsigned short date;
  138.     unsigned short time;
  139.     unsigned short flags;
  140.     /*CNF_VAR*/ void **config;
  141.     unsigned long unused_2;
  142. } N_AESINFO;
  143.  
  144.  
  145. /*
  146.  *    globale Variablen
  147.  */
  148. char *fpustr[]={"","68881/2","68881","68882","68040","","68060"};
  149. char *mchstr[4]={"ST","STE","TT"};
  150. char *fdcstr[]={"DD","HD","ED"};
  151.  
  152. /* Termcap-Variablen mit VT52-Sequenzem vorbelegt: */
  153. #define TT_LEN 40
  154. char tt_bold_on[TT_LEN]="p";
  155. char tt_reverse_on[TT_LEN]="p";
  156. char tt_end_all[TT_LEN]="q";
  157. char tt_curser_up[TT_LEN]="A";
  158. char tt_delete_line[TT_LEN]="l";
  159.  
  160. static METAINFO    metainfo={0L,NULL,0L,0L};
  161.  
  162.  
  163. /*
  164.  *    Prototypes
  165.  */
  166. void Metainit(METAINFO *buffer);
  167. #define    Metainit(buffer)    (void)trap_14_wl((short)(0x30),(long)(buffer))
  168.  
  169. extern short get_cpuclock(void);
  170. extern short get_fpuclock(void);
  171.  
  172. extern long get_long(long *aptr);
  173. extern char *hversionstr(char *s,short v);
  174. extern char *versionstr(char *s, short v);
  175. extern char *bcd_date(char *s, long l, short english);
  176. extern char *dos_date(char *s, DOSDATE d);
  177. extern void outline(char *lstr, char *mstr, char *rstr);
  178. extern void outversion(void);
  179. extern void outhardware(void);
  180. extern void outmemory(void);
  181. extern void outsoftware(void);
  182. extern void outdrives(void);
  183. extern int main(int argc, char *argv[], char *envp[]);
  184.  
  185.  
  186.  
  187. /*
  188.  *    Unterprogramme
  189.  */
  190.  
  191. char *hversionstr(char *s,short v)
  192. {
  193.     sprintf(s,"%x.%02x",v>>8,v&0xFF);
  194.     return s;
  195. }
  196.  
  197. char *versionstr(char *s,short v)
  198. {
  199.     sprintf(s,"%d.%02d",v>>8,v&0xFF);
  200.     return s;
  201. }
  202.  
  203. char *bcd_date(char *s,long l,short english)
  204. {
  205.     sprintf(s,"%02x.%02x.%02x",(short)((l>>(english ? 16:24))&0xFF),
  206.         (short)((l>>(english ? 24:16))&0xFF),(short)(l&0xFFFFL));
  207.     return s;
  208. }
  209.  
  210. char *dos_date(char *s,DOSDATE d)
  211. {
  212.     sprintf(s,"%02d.%02d.%04d",d.day,d.month,d.year+1980);
  213.     return s;
  214. }
  215.  
  216.  
  217. void outline(char *lstr,char *mstr,char *rstr)
  218. {
  219.     static void outspace(long val)
  220.     {
  221.         char s[100];
  222.         register int i;
  223.         for(i=0;(i<val)&&(i<100);s[i++]=' ');
  224.         s[i]='\0';
  225.         printf("%s",s);
  226.     }
  227.     if ((lstr) || (mstr) || (rstr)) {
  228.         if (lstr)
  229.             printf("%s%s%s",tt_bold_on,lstr,tt_end_all);
  230.         outspace(11L-strtst(lstr));
  231.         if (mstr)
  232.             printf("%s",mstr);
  233.         if (rstr) {
  234.             outspace(20L-strtst(mstr));
  235.             printf("%s",rstr);
  236.         }
  237.         printf("\n");
  238.     }
  239. }
  240.  
  241. void outversion(void)
  242. {
  243.     char rstr[80]="";
  244.     hversionstr(rstr,VERSION);
  245.     strcat(rstr,", ");
  246.     strcat(rstr,DATE);
  247.     outline("Sysinfo","Version",rstr);
  248.     outline(NULL,"Public Domain, written by Volker Hemsen",NULL);
  249. }
  250.  
  251. void outhardware(void)
  252. {
  253.     char rstr[80]="";
  254.     long l;
  255.     {
  256.         long cpu,cpucl=0L;
  257.         if (getcookie(_CPU,&cpu)) {
  258.             sprintf(rstr,"68%03d",(int)cpu);
  259.             if (!getcookie(_CPUC,&cpucl))
  260.             {
  261.                 if (cpu==30)
  262.                     cpucl=get_cpuclock();
  263.             }
  264.             if (cpucl)
  265.                 sprintf(&rstr[strlen(rstr)],"-%dMHz",(short)cpucl);
  266.         } else
  267.             strcpy(rstr,"unbekannt");
  268.         outline("Hardware","CPU",rstr);
  269.     }
  270.     {
  271.         long fpu,fpucl=0L;
  272.         if (getcookie(_FPU,&fpu)) {
  273.             fpu=((fpu>>16)&0xFFFF);
  274.             if (fpu==1)
  275.                 strcpy(rstr,"I/O-68881 (SFP 004)");
  276.             else {
  277.                 strcpy(rstr,fpustr[(fpu>>1)&7]);
  278.                 if (!getcookie(_FPUC,&fpucl))
  279.                     fpucl=get_fpuclock();
  280.                 if (fpucl)
  281.                     sprintf(&rstr[strlen(rstr)],"-%dMHz",(short)fpucl);
  282.             }
  283.             outline(NULL,"FPU",rstr);
  284.         }
  285.     }
  286.     if (getcookie(_MCH,&l)) {
  287.         if (l==0xFFFFFFFF)
  288.             strcpy(rstr,"Fremdhersteller");
  289.         else {
  290.             strcpy(rstr,mchstr[(l>>16)&3]);
  291.             if ((l&0xFFFF)==0x0010)
  292.                 strins(rstr,"MEGA ");
  293.         }
  294.         outline(NULL,"Rechnertyp",rstr);
  295.     }
  296.     if (getcookie(_MNAM,&l))
  297.         outline(NULL,"Systemname",(char*)l);
  298.     if (getcookie(_SND,&l)) {
  299.         if (l&1)
  300.             strcpy(rstr,"GI/Yamaha");
  301.         if (l&2)
  302.             strcat(rstr,", Stereo-DMA");
  303.         outline(NULL,"Sound",rstr);
  304.     }
  305.     if (getcookie(_VDO,&l)) {
  306.         strcpy(rstr,mchstr[(l>>16)&3]);
  307.         outline(NULL,"Videosystem",rstr);
  308.     }
  309.     {
  310.         register short bl=Blitmode(-1);
  311.         if (bl>=0) {
  312.             if (bl&2) {
  313.                 strcpy(rstr,"vorhanden und ");
  314.                 if (bl&1)
  315.                     strcat(rstr,"an");
  316.                 else
  317.                     strcat(rstr,"aus");
  318.             } else
  319.                 strcpy(rstr,"nicht vorhanden");
  320.             outline(NULL,"Blitter",rstr);
  321.         }
  322.     }
  323. }
  324.  
  325. void outmemory(void)
  326. {
  327.     static long ramsum_free=0L,ramsum_max=0L;
  328.     static void hasram(char *s,long maxmem,long freemem)
  329.     {
  330.         int prozent;
  331.         if ((maxmem!=-1) && (freemem!=-1)) {
  332.             ramsum_free+=freemem;
  333.             ramsum_max+=maxmem;
  334.         } else {
  335.             freemem=ramsum_free;
  336.             maxmem=ramsum_max;
  337.         }
  338.         prozent=(int)((freemem*100L)/maxmem);
  339.         sprintf(s,"% 6d:% 6dkB=% 2d%c  ",(int)(freemem>>10),(int)(maxmem>>10),prozent,'%');
  340.         {
  341.             register int ii;
  342.             register char *p;
  343.             char *c="*-";
  344.             if (*tt_reverse_on)
  345.                 c="-+";
  346.             strcat(s,tt_reverse_on);
  347.             p=&s[strlen(s)];
  348.             for(ii=5;ii<=prozent;ii+=5,*p++=*c);
  349.             strcpy(p,tt_end_all);
  350.             p+=strlen(tt_end_all);
  351.             for(ii=prozent;ii<100;ii+=5,*p++=c[1]);
  352.             *p='\0';
  353.         }
  354.     }
  355.     char rstr[80]="";
  356.     long l,lmax;
  357.     if (Sversion()>=0x1900)
  358.         l=(long)Mxalloc(-1L,0);
  359.     else
  360.         l=(long)Malloc(-1L);
  361.     lmax=get_long(PHYSTOP);
  362.     hasram(rstr,lmax,l);
  363.     outline("Speicher","ST-RAM",rstr);
  364.     if (get_long(RAMVALID)==0x1357bd13) {
  365.         rstr[0]=0;
  366.         if (Sversion()>=0x1900)
  367.             l=(long)Mxalloc(-1L,1);
  368.         else
  369.             l=0;
  370.         lmax=get_long(RAMTOP)-(1L<<24);
  371.         if (lmax>=0) {
  372.             hasram(rstr,lmax,l);
  373.             outline(NULL,"TT-RAM",rstr);
  374.         }
  375.     }
  376.     hasram(rstr,-1,-1);
  377.     outline(NULL,"Summe",rstr);
  378.     {
  379.         register OSHEADER *os=(OSHEADER*)get_long(SYSBASE);
  380.         if (os) {
  381.             sprintf(rstr,"$%lX",(long)os->os_beg);
  382.             outline(NULL,"ROM-Start",rstr);
  383.         }
  384.     }
  385. }
  386.  
  387. void outsoftware(void)
  388. {
  389.     char rstr[80]="";
  390.     long l;
  391. /*    OS-Version    */
  392.     {
  393.         register OSHEADER *os=(OSHEADER*)get_long(SYSBASE);
  394.         if (os) {
  395.             hversionstr(rstr,os->os_version);
  396.             strcat(rstr,", ");
  397.             bcd_date(&rstr[strlen(rstr)],os->os_date,1);
  398.             outline("Software","TOS",rstr);
  399.         }
  400.     }
  401. /*    GEMDOS-Version    */
  402.     outline(NULL,"GEMDOS-Version",hversionstr(rstr,intelshort(Sversion())));
  403. /*    Meta-DOS-Version    */
  404.     Metainit(&metainfo);
  405.     if (metainfo.version)
  406.         outline(NULL,"Meta-DOS",metainfo.version);
  407. /*    MiNT-Version    */
  408.     if (getcookie(_MiNT,&l))
  409.         outline(NULL,"MiNT-Version",versionstr(rstr,l));
  410. /*    Filelocking    */
  411.     if (getcookie(_FLK,&l))
  412.         outline(NULL,"File-Locking","verfügbar");
  413. /* TOS2GEM    */
  414.     {
  415.         TOS2GEM_COOKIE *t2gm;
  416.         if (getcookie(_T2GM,(long*)&t2gm)) {
  417.             short b;
  418.             dos_date(rstr,t2gm->date);
  419.             strcat(rstr,", (");
  420.             strcat(rstr,(b=(t2gm->reserve()))?"frei)":"belegt)");
  421.             if (b)
  422.                 t2gm->deinit();
  423.             outline(NULL,"TOS2GEM",rstr);
  424.         }
  425.     }
  426. /*    AES-Version    */
  427. /*    if (appl_init()>=0) {
  428.         hversionstr(rstr,_AESglobal[0]);
  429.         appl_exit();
  430.         outline(NULL,"AES-Version",rstr);
  431.     }*/
  432. /* N.AES-Version */
  433.     {
  434.         N_AESINFO* naes;
  435.         if (getcookie(_nAES,(long*)&naes)) {
  436.             hversionstr(rstr,naes->version);
  437.             strcat(rstr,(naes->flags&1)?" TT":" ST");
  438.           if (naes->flags&2)
  439.                 strcat(rstr," debug");
  440.             outline(NULL,"N.AES-Version",rstr);
  441.         }
  442.     }
  443. /*    GDOS-Kennung    */
  444.     if (vq_gdos()) {
  445.         l=vq_vgdos();
  446.         if (l>0L) {
  447.             strncpy(rstr,(char*)&l,4);
  448.             rstr[4]=0;
  449.         } else
  450.             strcpy(rstr,"unbekannt");
  451.         outline(NULL,"GDOS-Kennung",rstr);
  452.     }
  453. /*    NVDI-/NOVA-Version, Auflösung    */
  454.     {
  455.         NVDI_STRUCT    *nvdi;
  456.         if (getcookie(_NVDI,(long*)&nvdi)) {
  457.             hversionstr(rstr,nvdi->nvdi_version);
  458.             strcat(rstr,", ");
  459.             bcd_date(&rstr[strlen(rstr)],nvdi->nvdi_datum,0);
  460.             outline(NULL,"NVDI-Version",rstr);
  461.         }
  462.     }
  463.     {
  464.         ICB *icb=NULL;    /* NOVA-Treiber-Cookie    */
  465.         getcookie(_IMNE,(long*)&icb);
  466.         if (icb) {
  467.             strncpy(rstr,(char*)&icb->id,4);
  468.             rstr[4]=0;
  469.             outline(NULL,"NOVA-Treiberversion",rstr);
  470.             outline(NULL,"Auflösung",icb->name);
  471.         } else {
  472.             int work_out[57],vhandle=0,dummy;
  473.             int work_in[11]={1,1,1,1,1,1,1,1,1,1,2};
  474.             /*vhandle=graf_handle(&dummy,&dummy,&dummy,&dummy);*/
  475.             v_opnvwk(work_in,&vhandle,work_out);
  476.             if (vhandle>=1) {
  477.                 sprintf(rstr,"%dx%dx",work_out[0]+1,work_out[1]+1);
  478.                 switch(work_out[13]) {
  479.                     case 0:    strcat(rstr,"true color");
  480.                     case 0x7FFF:    strcat(rstr,"high color");
  481.                     default:    sprintf(&rstr[strlen(rstr)],"%d",work_out[13]);
  482.                 }
  483.                 v_clsvwk(vhandle);
  484.                 outline(NULL,"Auflösung",rstr);
  485.             }
  486.         }
  487.     }
  488. }
  489.  
  490. void outdrives(void)
  491. {
  492.     static char *drivelist(char *rstr,ULONG drivemap)
  493.     {
  494.         register char *u=rstr;
  495.         register int jj;
  496.         for(jj=0;jj<32;jj++,drivemap>>=1)
  497.             if (drivemap&1)
  498.                 *u++=(char)(0x41+jj);
  499.         *u=0;
  500.         return rstr;
  501.     }
  502.     char rstr[80]="";
  503. /*    GEMDOS-Laufwerke    */
  504.     outline("Laufwerke","GEMDOS-Liste",drivelist(rstr,Dsetdrv((int)Dgetdrv())));
  505. /*    Meta-DOS-Laufwerke    */
  506.     Metainit(&metainfo);
  507.     if (metainfo.version)
  508.         outline(NULL,"MetaDOS-Liste",drivelist(rstr,metainfo.drivemap));
  509. /*    Diskettenlaufwerke    */
  510.     {
  511.         long l;
  512.         sprintf(rstr,"%d",(short)get_long(NFLOPS));
  513.         if (getcookie(_FDC,&l)) {
  514.             l=((l&0xFFFFFFL)<<8);
  515.             sprintf(&rstr[strlen(rstr)]," x %s:%s",fdcstr[(l>>24)&3],(char*)&l);
  516.         }
  517.         outline(NULL,"Diskettenlaufwerke",rstr);
  518.     }
  519. /*    AHDI-Festplatten    */
  520.     {
  521.         register PUN_INFO *puninfo=(PUN_INFO*)get_long(PUNPTR);
  522.         if (puninfo!=NULL) {
  523.             sprintf(rstr,"%d",puninfo->puns);
  524.             outline(NULL,"Festplatten",rstr);
  525.             strncpy(rstr,(char*)&puninfo->P_cookie,4);
  526.             rstr[4]=' ';
  527.             hversionstr(&rstr[5],puninfo->P_version);
  528.             outline(NULL,"HD-Treiber",rstr);
  529.         }
  530.     }
  531.     {
  532.         int v=XHGetVersion();
  533.         if (v>0) {
  534.             outline(NULL,"XHDI-Version",hversionstr(rstr,v));
  535.             outline(NULL,"XHDI-Liste",drivelist(rstr,(ULONG)XHDrvMap()));
  536.         }
  537.     }
  538. }
  539.  
  540. int main(int argc,char *argv[],char *envp[])
  541. {
  542.     boolean wait_key=FALSE;
  543.     static void ask_for_key(boolean mode)
  544.     {
  545.         if (wait_key) {
  546.             printf("%sFür %s Return-Taste drücken!%s",(mode)?tt_reverse_on:tt_bold_on,
  547.                 (mode)?"Ende":"Weiter",tt_end_all);
  548.             fgetc(stdin);
  549.             if (!mode)
  550.                 printf("%s%s",tt_curser_up,tt_delete_line);
  551.         }
  552.     }
  553.     boolean out_version=FALSE,out_hardware=FALSE,out_software=FALSE,out_memory=FALSE;
  554.     boolean out_drives=FALSE,out_help=FALSE;
  555.     static boolean getopt(char *s)
  556.     {
  557.         if (*s=='-')
  558.             switch(s[1]) {
  559.                 case 'i':
  560.                 case 'v':    out_version=TRUE;    break;
  561.                 case 'a':    out_hardware=TRUE;    out_memory=TRUE;    out_software=TRUE;    out_drives=TRUE;    break;
  562.                 case 'h':    out_hardware=TRUE;    break;
  563.                 case 'r':
  564.                 case 'm':    out_memory=TRUE;    break;
  565.                 case 's':
  566.                 case 'o':    out_software=TRUE;    break;
  567.                 case 'l':
  568.                 case 'd':
  569.                 case 'f':    out_drives=TRUE;    break;
  570.                 case 'k':
  571.                 case 'w':    wait_key=TRUE;    break;
  572.                 default:    out_help=TRUE;    out_version=TRUE;    break;
  573.             }
  574.         return FALSE;
  575.     }
  576.     if (initterm()) {
  577.         if (!tgetstrx("md",tt_bold_on))
  578.             tgetstrx("so",tt_bold_on);
  579.         tgetstrx("mr",tt_reverse_on);
  580.         if (!tgetstrx("me",tt_end_all))
  581.             tgetstrx("se",tt_end_all);
  582.         tgetstrx("dl",tt_delete_line);
  583.         tgetstrx("up",tt_curser_up);
  584.     }
  585.     getargvopt(argc,argv,getopt);
  586.     if (out_version)        outversion();
  587.     if (out_help) {
  588.         outline("Syntax","-v(ersion) -w(ait for key) -a(ll)",NULL);
  589.         outline(NULL,"-h(ardware) -m(emory) -s(oftware) -l(aufwerke)",NULL);
  590.     }
  591.     if ((!out_hardware)&&(!out_memory)&&(!out_software)&&(!out_drives)) {
  592.         out_hardware=TRUE;
  593.         out_memory=TRUE;
  594.         out_software=TRUE;
  595.         out_drives=TRUE;
  596.     }
  597.     if (out_hardware) {
  598.         if ((out_version)||(out_help))
  599.             ask_for_key(FALSE);
  600.         outhardware();
  601.     }
  602.     if (out_memory) {
  603.         ask_for_key(FALSE);
  604.         outmemory();
  605.     }
  606.     if (out_software) {
  607.         ask_for_key(FALSE);
  608.         outsoftware();
  609.     }
  610.     if (out_drives) {
  611.         ask_for_key(FALSE);
  612.         outdrives();
  613.     }
  614.     ask_for_key(TRUE);
  615.     return 0;
  616. }
  617.